//
//  "$Id: VideoAnalyseRule.h 110528 2013-04-09 06:00:55Z zhao_zhiding $"
//
//  Copyright (c)1992-2007, ZheJiang Dahua Technology Stock CO.LTD.
//  All Rights Reserved.
//
//	Description:	所有坐标点和尺寸按照帧画面的绝对坐标系，分辨率变化后
//					相关参数需要重新设置
//	Revisions:		Year-Month-Day  SVN-Author  Modification
//

#ifndef __VIDEO_ANALYSE_RULE_API_H__
#define __VIDEO_ANALYSE_RULE_API_H__

#include "Types.h"

#ifdef __cplusplus
extern "C" {
#endif

/// 视频分析规则类型
typedef enum VideoAnalyseRuleType
{
	videoAnalyseCrossLineDetection		= 0,	///< 越线检测
	videoAnalyseCrossRegionDetection	= 1,	///< 区域检测
	videoAnalysePasteDetection			= 2,	///< ATM贴条检测
	videoAnalyseLeftDetection			= 3,	///< 物品遗留/遗洒检测
	videoAnalysePreservation			= 4,	///< 物品保全检测
	videoAnalyseStayDetection			= 5,	///< 停留检测
	videoAnalyseWanderDetection			= 6,	///< 徘徊检测
	videoAnalyseMoveDetection			= 7,	///< 运动检测
	videoAnalyseTailDetection			= 8,	///< 尾随检测
	videoAnalyseRioterDetection			= 9,	///< 聚众暴乱检测
	videoAnalyseFireDetection			= 10,	///< 火焰检测
	videoAnalyseSmokeDetection			= 11,	///< 烟雾检测
	videoAnalyseFightDetection			= 12,	///< 打架检测
	videoAnalyseFlowStat				= 13,	///< 人头统计
	videoAnalyseNumberStat				= 14,	///< 数量统计
	videoAnalyseCameraCoverdDetection	= 15,	///< 摄像机遮盖检测
	videoAnalyseCameraMovedDetection	= 16,	///< 摄像机移动检测
	videoAnalyseVideoAbnormalDetection	= 17,	///< 视频异常检测
	videoAnalyseVideoBadDetection		= 18,	///< 视频损坏检测
	videoAnalyseCrossFenceDetection		= 19,	///< 翻越围栏检测
	videoAnalyseTakeAwayDetection		= 20,	///< 物品搬移检测
	videoAnalyseParkingDetection		= 21,	///< 非法停车检测
	videoAnalyseRetrogradeDetection		= 22,	///< 逆行检测
	videoAnalyseFaceDetection			= 23,	///< 人脸检测
	videoAnalyseRuleTypeFaceRecognition	= 24,	///< 人脸识别
	videoAnalysePlateLicenseDetection	= 25,	///< 车牌识别
	videoAnalyseParkingSpaceDetection	= 26,	///< 普通车位检测
	videoAnalyseObjectDetection			= 27,	///< 物品检测（包含物品搬移，物品遗留)
	videoAnalyseObjectClassify			= 28,	///< 目标分类

	videoAnlayseQueueDetect				= 29,	///< 排队检测
	videoAnalyseDensityDetection		= 30,	///< 人群密度检测
	videoAnalyseRunDetection			= 31,	///< 异常奔跑检测
	
	/// 交通类规则
	videoAnalyseTrafficControl			= 32,	///< 交通管制检测(限时，限牌，限车型，限经停)
	videoAnalyseTrafficAccident			= 33,	///< 交通事故检测
	videoAnalyseTrafficJunction			= 34,	///< 交通路口检测(闯红灯,禁左,禁右,掉头,压线，逆行，超速，欠速)
	videoAnalyseTrafficGate				= 35,	///< 交通卡口检测
	videoAnalyseTrafficParking			= 36,	///< 违章停车
	videoAnalyseTrafficJam				= 37,	///< 交通拥堵
	videoAnalyseTrafficWrongLane		= 38,	///< 不按车道行驶
	videoAnalyseTrafficCrossLane		= 39,	///< 非法变道
	videoAnalyseTrafficRunRedLight		= 40,	///< 闯红灯
	videoAnalyseTrafficOverLine			= 41,	///< 压白车道线
	videoAnalyseTrafficOverYellowLine	= 42,	///< 压黄车道线
	videoAnalyseTrafficRetrograde		= 43,	///< 逆行
	videoAnalyseTrafficTurnLeft			= 44,	///< 违章左转
	videoAnalyseTrafficTurnRight		= 45,	///< 违章右转
	videoAnalyseTrafficUTurn			= 46,	///< 违章调头
	videoAnalyseTrafficWaitingArea		= 47,	///< 违章进入待行区
	videoAnalyseTrafficOverSpeed		= 48,	///< 超速
	videoAnalyseTrafficUnderSpeed		= 49,	///< 欠速
	videoAnalyseTrafficYellowPlate		= 50,	///< 黄牌占道
	videoAnalyseTrafficDriveOnShoulder	= 51,	///< 路肩行驶
	videoAnalyseTrafficVehicleInRoute	= 52,	///< 有车占道
	videoAnalyseTrafficStay				= 53,	///< 违章滞留
	videoAnalyseTrafficPedestrainPriority =54,	///< 行人礼让
	videoAnlayseTrafficFlowStatUpper	= 55,	///< 交通流量统计流量过高
	videoAnlayseTrafficFlowStatLower	= 56,	///< 交通流量统计流量过低
	videoAnalyseTrafficVehicleInBusRoute= 57,	///< 违章占道
	videoAnalyseTrafficBacking			= 58,	///< 违章倒车
	videoAnalyseTrafficOverStopLine		= 59,	///< 压停止线
	videoAnalyseTrafficRunYellowLight	= 60,	///< 闯黄灯
	videoAnlayseTrafficParkingOnYellowBox = 61, ///<黄网格线内违章停车

	/// VQD类型规则
	videoAnalyseBlurDetection			= 63,		///< 相机模糊检测
	videoAnalyseUnbalanceDetection		= 64,		///< 相机偏色检测

	//出入口检测规则
	videoAnalyseParkingGateway			= 65,		///< 停车场出入口检测
	videoAnalyseAbnormalFaceDetection	= 66,		///< 异常人脸检测
	videoAnalyseHumanShapeDetection	    = 67,	    ///< 人形检测
	videoAnalysePersonVehicleNonmotor	= 68,	    ///< 人车非检测

	videoAnalyseAutoRun             	= 69,	    ///< 自运行
} VideoAnalyseRuleType;


/// 触发报警位置
typedef enum VideoAnalyseTriggerPosition
{
	videoAnalyseTriggerCenter		= 1 << 0,	///< 目标外接框中心
	videoAnalyseTriggerLeftCenter	= 1 << 1,	///< 目标外接框左端中心
	videoAnalyseTriggerTopCenter	= 1 << 2,	///< 目标外接框顶端中心
	videoAnalyseTriggerRightCenter	= 1 << 3,	///< 目标外接框右端中心
	videoAnalyseTriggerBottomCenter	= 1 << 4,	///< 目标外接框底端中心
} VideoAnalyseTriggerPosition;


/// 经过检测线的方向
typedef enum VideoAnalyseCrossLineDirection
{
	videoAnalyseCrossLineLeftToRight,	///< 从左到右
	videoAnalyseCrossLineRightToLeft,	///< 从右到或
	videoAnalyseCrossLineBoth,			///< 双向
} VideoAnalyseCrossLineDirection;


/// 经过检测区域的方向
typedef enum VideoAnalyseCrossRegionDirection
{
	videoAnalyseCrossRegionEnter,		///< 进入
	videoAnalyseCrossRegionLeave,		///< 离开
	videoAnalyseCrossRegionBoth,		///< 双向
} VideoAnalyseCrossRegionDirection;


/// 检测动作
typedef enum VideoAnalysePasteAction
{
	videoAnalysePasteActionExist	= 1 << 0,	///< 贴条报警开始
	videoAnalysePasteActionTaken	= 1 << 1,	///< 贴条报警结束
} VideoAnalysePasteAction;

/// 检测动作
typedef enum VideoAnalyseDetectAction
{
	videoAnalyseDetectActionAppear		= 1 << 0,	///< 出现
	videoAnalyseDetectActionDisappear	= 1 << 1,	///< 消失
	videoAnalyseDetectActionInside		= 1 << 2,	///< 在区域内
	videoAnalyseDetectActionCross		= 1 << 3,	///< 穿越区域
} VideoAnalyseDetectAction;

/// 密集状态
typedef enum VideoAnalyseDensityState
{
	videoAnalyseDensityRare				= 1 << 0,	///< 很稀疏
	videoAnalyseDensitySparse			= 1 << 1,	///< 稀疏
	videoAnalyseDensityDense			= 1 << 2,	///< 密集
	videoAnalyseDensityCrowded			= 1 << 3,	///< 拥挤
}VideoAnalyseDensityState;

/// 异常奔跑类型
typedef enum VideoAnalyseRunDetectType
{
	videoAnalyseRunFast				= 1 << 0,	///< 快速奔跑
	videoAnalyseRunAbruptSpeedUp	= 1 << 1,	///< 突然加速
	videoAnalyseRunAbruptSpeedDown	= 1 << 2,	///< 突然减速
} VideoAnalyseRunDetectType;

/// 视频异常类型掩码
typedef enum VideoAnalyseVideoAbnormalDetectionMask
{
	videoAnalyseVideoAbnormalLoss		= 1 << 0,	///< 视频丢失
	videoAnalyseVideoAbnormalCover		= 1 << 1,	///< 视频遮挡
	videoAnalyseVideoAbnormalFrozen		= 1 << 2,	///< 画面冻结
	videoAnalyseVideoAbnormalLight		= 1 << 3,	///< 过亮
	videoAnalyseVideoAbnormalDark		= 1 << 4,	///< 过暗
	videoAnalyseVideoAbnormalSceneChange= 1 << 5,	///< 场景变化
} VideoAnalyseVideoAbnormalDetectionMask;

/// 普通车位检测动作
typedef enum VideoAnalysePackingDetectAction
{
	videoAnalyseParkingSpaceFree		= 1 << 0,	///< 车位空闲
	videoAnalyseParkingSpaceUse			= 1 << 1,	///< 车位使用
	videoAnalyseParkingSpaceBook		= 1 << 2,	///< 车位预定
} VideoAnalysePackingDetectAction;

/// 视频分析检查规则配置，128字节
typedef struct VideoAnalyseRuleConfig
{
	uint						id : 8;				///< 规则ID
	uint						enable : 8;			///< 是否使能
	VideoAnalyseRuleType		ruleType : 8;		///< 规则类型
	uint						objectTypeMask;		///< 支持的物体类型掩码
	uint						objectCategoryMask;	///< 支持的物体子类型掩码，此时物体类型只能选一种
	int							reserved[5];		///< 保留
	union
	{
		struct CrossLine										///< 警戒线配置
		{
			VideoAnalyseBoundary			detectLine;			///< 警戒线
			ulong							triggerPositionMask;///< 触发报警位置掩码，取值参见 VideoAnalyseCrossLineDirection
			VideoAnalyseCrossLineDirection	direction : 8;		///< 检测方向
			VideoAnalyseSizeFilter*			sizeFilter;			///< 尺寸过滤器
			VideoAnalyseSizeFilterNew *	sizeFilterNew;			///<新尺寸过滤器，新尺寸过滤器有效时，老的无效；
			short							alarmInterval;		///< 报警间隔时间
		} crossLine;
		
		struct CrossFence										///< 翻越围栏规则
		{
			VideoAnalyseBoundary			upstairsLine;		///< 围栏上面的一条线
			VideoAnalyseBoundary			downstairsLine;		///< 围栏下面的一条线
			ulong							triggerPositionMask;///< 触发报警位置掩码，取值参见 VideoAnalyseCrossLineDirection
			VideoAnalyseCrossLineDirection	direction : 8;		///< 检测方向
			VideoAnalyseSizeFilter*			sizeFilter;			///< 尺寸过滤器
			VideoAnalyseSizeFilterNew *	sizeFilterNew;			///<新尺寸过滤器，新尺寸过滤器有效时，老的无效；
			short							alarmInterval;		///< 报警间隔时间
		} crossFence;
		
		struct CrossRegion										///< 警戒区入侵配置
		{
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			ushort							minDuration; 		///< 最短持续时间，单位：秒
			ushort							reportInterval; 	///< 报告时间间隔，单位：秒
			ulong							actionMask;			///< 检测动作掩码，参见 VideoAnalyseDetectAction
			VideoAnalyseCrossRegionDirection direction : 8;		///< 检测方向
			uchar							placeholder[3];		///< 点位保留
			ushort							minTargets;			///< 最小目标个数
			ushort							maxTargets;			///< 最大目标个数
			VideoAnalyseSizeFilter*			sizeFilter;			///< 尺寸过滤器
			VideoAnalyseSizeFilterNew *	sizeFilterNew;			///<新尺寸过滤器，新尺寸过滤器有效时，老的无效；
		} crossRegion;
		
		struct Preservation										///< 物品保全
		{
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			ushort							minDuration; 		///< 最短持续时间，单位：秒
		} preservation;
		
		struct ObjectLeft										///< 遗留物品规则
		{
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			ushort							minDuration; 		///< 最短持续时间，单位：秒,遗留范围4s~300s，盗移范围0s~10s
			ulong							triggerPositionMask;///< 触发报警位置掩码，取值参见 VideoAnalyseCrossLineDirection
			VideoAnalyseSizeFilter*			sizeFilter;			///< 尺寸过滤器
			VideoAnalyseSizeFilterNew*		sizeFilterNew;		///< 新尺寸过滤器，新尺寸过滤器有效时，老的无效；
			ushort							reportInterval; 	///< 报告时间间隔，单位：秒
		} left;
		
		struct ObjectLeft takeAway;								///< 物品搬移规则

		struct ObjectLeft ObjectDetection;						///< 物品检测规则，包括了物体遗留和物品搬移
		
		struct ObjectLeft parking;								///< 非法停车规则

		struct ObjectLeft parkingSpaceDetection;				///< 普通停车位检测规则

		struct ObjectLeft plateLicenseDetection;				///< 停车位车牌检测规则

		struct Wander											///< 徘徊
		{
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			ushort							minDuration; 		///< 最短持续时间，单位：秒,范围5s~600s
			ushort							reportInterval; 	///< 报告时间间隔，单位：秒
			ulong							triggerPositionMask;///< 触发报警位置掩码，取值参见 VideoAnalyseCrossLineDirection
			ushort							triggerTargets;		///< 触发报警人数
			VideoAnalyseSizeFilter*			sizeFilter;			///< 尺寸过滤器
			VideoAnalyseSizeFilterNew *	sizeFilterNew;			///<新尺寸过滤器，新尺寸过滤器有效时，老的无效；
		} wander;
		
		struct Wander stay;										///< 滞留
		
		struct Rioter											///< 聚集检测
		{
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			ushort							minDuration;		///< 最短持续时间，单位：秒
			char							areaPercent;		///< 仅作兼容保留，使用 sensitivity
			uchar							sensitivity;		///< 灵敏度，取值1-10，值越小灵敏度越低，对应人群的密集程度越高。
			Rect		minDetectRect;			///< 矩形框，分别对应矩形框的左上和右下点，矩形框的实际面积表示触发报警的最小人群聚集面积；
			ushort 		alarmInterval; 			///< 报警间隔时间，单位：秒
			VideoAnalyseDensityState 		densityState;		///< 密度阀值状态，超出这个阀值状态后，开始报警。
		} rioter;
		
		struct Rioter density;									///< 人群密度检测

		struct FlowStat											///< 数量统计检测
		{
			VideoAnalyseBoundary			detectLine;			///< 检测线
			VideoAnalyseCrossLineDirection	direction;			///< 检测方向
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			Point							forwardDirection[2];		///< 正常行驶方向；第一个点是起点，第二个点是终点，点的坐标归一化到[0,8192)区间
		}flowstat;

		struct FlowStat headCount;								///< 人数统计
		struct Retrograde										///< 逆行
		{
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			int								retrogradeLength;   ///< 逆行距离约束，CIF下，32~256px,8192分辨率下，范围815~6750
			ulong							triggerPositionMask;///< 触发报警位置掩码，取值参见 VideoAnalyseCrossLineDirection
			Point							direction[2];		///< 正常行驶方向；第一个点是起点，第二个点是终点，点的坐标归一化到[0,8192)区间
			uchar							sensitivity;		///< 灵敏度，取值1-10，值越小灵敏度越低。
			VideoAnalyseSizeFilter*			sizeFilter;			///< 尺寸过滤器
			VideoAnalyseSizeFilterNew *	sizeFilterNew;			///<新尺寸过滤器，新尺寸过滤器有效时，老的无效；
			short							alarmInterval;		///< 报警间隔时间
		} retrograde;
		
		struct Run												///< 异常奔跑
		{
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			ushort							minDuration;		///< 最短持续时间，单位：秒
			ulong							triggerPositionMask;///< 触发报警位置掩码，取值参见 VideoAnalyseCrossLineDirection
			ulong							typeMask;			///< 奔跑类型掩码，取值见 VideoAnalyseRunDetectType
			uchar							triggerSpeed;		///< 触发速度，大于该速度报警；单位：km/h
			uchar							sensitivity;		///< 灵敏度，取值1-10，值越小灵敏度越低。
			VideoAnalyseSizeFilter*			sizeFilter;			///< 尺寸过滤器
			VideoAnalyseSizeFilterNew *	sizeFilterNew;			///<新尺寸过滤器，新尺寸过滤器有效时，老的无效；
		} run;
		
		struct Fight											///< 打架检测规则
		{
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			ushort							minDuration;		///< 最短持续时间，单位：秒
		} fight;

		struct VideoAbnormalDetection							///< 视频异常检测
		{
			ulong							typeMask;			///< 视频异常类型掩码, 取值见 VideoAnalyseVideoAbnormalDetectionMask
			ushort							minDuration;		///< 最短持续时间，单位：秒
			uchar							sensitivity;		///< 灵敏度，取值1-10，值越小灵敏度越低。只对Cover，Light，Dark，SceneChange类型有效
		} videoAbnormalDetection;

		/////////////////// 交通规则配置 //////////////////////////////////////
		/// 以下规则使用通用配置：卡口,逆行,逆行, 违章变道,不按车道行驶, 行人礼让
		/// 禁左,禁右,违章掉头,有车占道,黄牌占道,违章占道,违章倒车。其他规则使用各自对应的配置。
		///////////////////////////////////////////////////////////////////////
		struct TrafficGeneralConfig					///< 通用交通规则配置
		{
			char					laneNumber;		///< 车道编号，从0开始
		} trafficGeneral;
		
		struct TrafficOverLineConfig				///< 压白线,压黄线配置
		{
			char					laneNumber;		///< 车道编号，从0开始
			char					sensitivity;	///< 灵敏度，取值1-10，数值越大代表灵敏度越高
		} trafficOverLine;

		struct TrafficJunctionConfig				///< 卡口规则配置.
		{
			char					laneNumber;		///< 车道编号，从0开始
			VideoAnalyseBoundary 	detectLine;		///< 报警线
		} trafficGate;
		
		struct TrafficRunRedLightConfig				///< 闯红灯配置
		{
			char					laneNumber;		///< 车道编号，从0开始
			VideoAnalyseBoundary	preLine;		///< 前置触发线
			VideoAnalyseBoundary	middleLine;		///< 中间触发线
			VideoAnalyseBoundary	postLine;		///< 后置触发线
			uchar					margin;			///< 红灯冗余时间，单位秒
			uchar					judgmentMask;	///< 违章判定依据掩码，0:按车道属性，1:按车辆行驶方向
			uchar					measureMode;	///< 计量方式，0-像素，1-实际长度，单位厘米
			ushort					lastSnapPosition;	///< 闯红灯第三张违章抓拍相对于停止线的位置，单位参考measureMode
		} trafficRunRedLight;
		struct TrafficRunYellowLightConfig			///< 闯黄灯配置
		{
			char					laneNumber;		///< 车道编号，从0开始
			VideoAnalyseBoundary	preLine;		///< 前置触发线
			VideoAnalyseBoundary	middleLine;		///< 中间触发线
			VideoAnalyseBoundary	postLine;		///< 后置触发线
			uchar					margin;			///< 黄灯冗余时间，单位秒
			uchar					judgmentMask;	///< 违章判定依据掩码，0:按车道属性，1:按车辆行驶方向
			uchar					measureMode;	///< 计量方式，0-像素，1-实际长度
			ushort					lastSnapPosition;	///< 闯黄灯第三张违章抓拍相对于停止线的位置，单位参考measureMode
		} trafficRunYellowLight;
		struct TrafficParkingConfig					///< 违章停车规则配置
		{
			char					laneNumber;		///< 车道编号，从0开始
			ushort					delay;			///< 检测到违章停车到开始上报的时间，秒为单位
			ushort					interval;		///< 报警间隔时间，单位秒
			ushort					reportTimes;	///< 上报次数			
		} trafficParking;
		struct TrafficParkingOnYellowBoxConfig
		{	
			char 					laneNumber;		///<车道编号，从0开始	
			ushort 					interval1;		///<第二张和第一张的延时时间，单位秒
			ushort 					interval2;		///<第三张和第二张的延时时间，单位秒
			ushort					followTime;		///<跟随时间，如果一辆车与前一辆车进入黄网格
													///<的时间差小于此值，就认为是跟车进入
													///<跟车进入情况下如果停车则不算违章
		} trafficParkingOnYellowBox;

		struct TrafficStayConfig					///< 违章滞留规则配置
		{
			char					laneNumber;		///< 车道编号，从0开始
			ushort					delay;			///< 检测到停车到开始上报的时间，秒为单位
			ushort					interval;		///< 报警间隔时间，单位秒	
		} trafficStay;
		
		struct TrafficJamConfig						///< 交通拥堵规则配置
		{
			char					laneNumber;		///< 车道编号，从0开始
			ushort					delay;			///< 检测到拥堵到开始上报的时间，秒为单位
			ushort					interval;		///< 报警间隔时间，秒为单位
			ushort					reportTimes;	///< 上报次数	
		} trafficJam;
		
		struct TrafficSpeedLimitConfig				///< 限速配置. 超欠速复用该结构体
		{
			char					laneNumber;		///< 车道编号，从0开始
			uchar					maxSpeed;		///< 最大限速，区分大小车时为小车限速值
			uchar					minSpeed;		///< 最小限速，区分大小车时为小车限速值
			uchar					speedLimitForSize;			///< 是否区分大小车，0-不区分，1-区分
			uchar					bigCarMaxSpeed;				///< 大车最大限速值，区分大小车时有效
			uchar					bigCarMinSpeed;				///< 大车最低限速值，区分大小车时有效
		} trafficSpeedLimit;
		
		struct TrafficWaitingAreaConfig				///< 违章驶入待行区
		{
			char					laneNumber;		///< 车道编号，从0开始
			VideoAnalyseBoundary	waitingArea;	///< 待行区区域
		}waitingArea;		

		struct TrafficFlowStatConfig				///< 交通流量统计流量过高
		{
			char 			laneNumber;				///< 车道编号
			uint 			period;					///< 统计周期，分钟
			ushort			limit;					///< 报警上限值
			ushort			restore;				///< 报警恢复值
			ushort			delay;					///< 报警延迟,单位秒.
			ushort			interval;				///< 报警间隔时间
			ushort			reportTimes;			///< 上报次数
		} trafficFlowStatUpper;
		
		struct TrafficOverStopLine					///< 压停止线事件
		{
			char			laneNumber;				///< 车道号
			ushort			delayTime;				///< 第三张抓拍的延时时间，单位秒
		}trafficOverStopLine;
		
		struct FaceDetection
		{
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			ulong							fdTypeMask; 		///<人脸类型掩码
		}faceDetection;

		struct FaceDetection abnormalFaceDetection;				///< 异常人脸检测

		struct TrafficFlowStatConfig trafficFlowStatLower;	///< 交通流量统计流量过低

		struct QueueDetect								///< 排队检测配置
		{
			Point	detectLine[2];						///< [Point, Point],	检测线（两点）	Point的定义见《大华信息交换格式》
			uint 	occupyLineMargin : 8;				///< 占线限值，队伍长度占线比例限值	0-100
			uint	reservedBits : 24;					///< 保留位
			uint	triggerTime;						///< 排队检测报警时间 排队超过阈值的状态维持了“排队检测报警时间”以后报警	单位s
		}queueDetect;

		struct PasteDetection
		{
			VideoAnalyseBoundary			detectRegion;		///< 检测区域
			ushort							minDuration; 		///< 最短持续时间，单位：秒
			ulong							actionMask;			///< 检测动作掩码，参见 VideoAnalyseDetectAction
			VideoAnalyseCrossRegionDirection direction : 8;		///< 检测方向
			VideoAnalyseSizeFilter*			sizeFilter;			///< 尺寸过滤器
			VideoAnalyseSizeFilterNew *	sizeFilterNew;			///<新尺寸过滤器，新尺寸过滤器有效时，老的无效；
		}pasteDetection;

		struct VQDConfig
		{
			ushort					interval;			///< 报警间隔时间，秒为单位
			uchar					sensitivity;		///< 灵敏度，取值1-10，值越小灵敏度越低。
		}cameraMovedDetection;							///< 相机移动检测

		struct VQDConfig blurDetection;					///< 相机模糊检测

		struct VQDConfig unbalanceDetection;			///< 相机偏色检测

		struct HumanShapeDetection							///< 人形检测 
		{
			VideoAnalyseBoundary    detectRegion;		///< 检测区域
			ushort					minDuration; 		///< 最短持续时间，单位：秒
		} humanShapeDetection;

		int placeholder[24]; ///< 占位符，保证这个联合体体为96字节
	}config;
} VideoAnalyseRuleConfig;

/// 车标结构体，64字节
typedef struct VideoAnalyseTrafficVehicleSign
{
	Rect	boundingBox;		///< 车标位置
	int		reversed[12];		///< 保留字节
}VideoAnalyseTrafficVehicleSign;

/// 视频分析物体额外信息，128字节
typedef union VideoAnalyseObjectEx
{
	struct videoAnalyseVehicle						///< 车辆额外信息
	{
		VideoAnalyseTrafficLightCategory turn;		///< 交通车辆转弯方向
		VideoAnalyseTrafficVehicleSign* sign;		///< 车标信息，为空表示不存在车标，车标类型放在VideoAnalyseObject的text字段
	} vehicle;
	struct videoAnalyseTrafficLight
	{
		uint state;								///< 交通灯状态,按bit表示，1-亮，0-灭。bit0-bit7,bit8-bit15,bit16-bit23依次表示红灯、黄灯、绿灯各个方向灯的状态
												///< 每个8位组的低4位依次表示左转灯、直行灯、右转灯，调头灯
	} trafficLight;

	struct videoAnalyseFace						///< 人脸检测额外信息
	{
		char frontalFaceFlag;					///< 正脸标示，0：正脸 非0：侧脸
		char confidenceFlag;					///< 人脸置信度是否有效的标志位，1:有效，0:无效
	} face;

	int placeholder[32]; ///< 占位符，保证这个联合体体为128字节
} VideoAnalyseObjectEx;

///物体额外信息，64字节
typedef union VideoObjectEx
{
	struct videoOriginalFace						///< 人脸检测额外信息
	{
		char frontalFaceFlag;					///< 正脸标示，0：正脸 非0：侧脸
		char confidenceFlag;					///< 人脸置信度是否有效的标志位，1:有效，0:无效
	} face;

	int placeholder[16]; ///< 占位符，保证这个联合体体为64字节
}VideoObjectEx;

//交通灯异常. 可能导致信号检测不准.
typedef enum VideoAnalyseTrafficLightAbnormalType
{
	videoAnalyseTrafficLightExcursion,		///< 交通灯偏移
	videoAnalyseTrafficLightCrushout,		///< 交通灯熄灭
	videoAnalyseTrafficLightWobble,			///< 交通灯抖动
	videoAnalyseTrafficLightSwitch,			///< 交通灯切换异常
}VideoAnalyseTrafficLightAbnormalType;

/// 事件来源
typedef enum VideoAnalyseTriggerSrc
{
	VideoAnalyseTriggerVideo = 0,			///< 视频触发
	VideoAnalyseTriggerSimulation,			///< 模拟触发
	VideoAnalyseTriggerComm485,				///< 485触发
	VideoAnalyseTriggerComm232,				///< 232触发
	VideoAnalyseTriggerIO,					///< IO触发
}VideoAnalyseTriggerSrc;

typedef struct VideoAnalyseCompInfo
{
	char lib[48];							///< 库名
	char name[48];							///< 人名
	int similar;							///< 相似度
}VideoAnalyseCompInfo;

/// 视频分析规则产生的事件，128字节
typedef struct VideoAnalyseEvent
{
	uint					ruleId : 8;			///< 所属规则ID
	VideoAnalyseRuleType	ruleType : 8;		///< 规则类型
	int 					indexInGroup : 8;	///< 一个事件组里的事件序号, 0为无效, 如果为组图则组图无效,其他为有效.
	int						sequence : 8;		///< 序号. 按照抓拍张数的的逆序, 以1/0结束.1表示违章发生,正常结束. 0表示未发生,
	uint					objectId;			///< 相关物体ID列表
	uint					objectCount : 16;			///< 物体数量
	int						reservedBits : 16;			///< 保留位

	///< 物体ID列表，物体ID列表，注: 为了兼容以前的objectId，在objectIdCount=1时,物体ID仍然放到objectId,只有objectIdCount>=2时, 物体ID列表放到objectIds中;
	uint*					objectIds;					///< 相关物体ID列表,底层分配置内存，应用层注意释放内存;
	VideoAnalyseTriggerSrc 	triggerType;				///< 事件触发类型
	int						reserved[3];				///< 保留字节，保证非联合部分为32字节
	union
	{
		/////////////////// IVS检测事件 ///////////////////////////////////////
		/// 
		/// 
		///////////////////////////////////////////////////////////////////////
		struct CrossLineEvent									///< 警戒线事件
		{
			VideoAnalyseCrossLineDirection	direction : 8;		///< 检测方向
		} crossLine;
		struct CrossLineEvent crossFence;						///< 翻越围栏事件

		struct pasteEvent 										///< 贴条事件
		{
			VideoAnalysePasteAction		action;
		} paste;

		struct CrossRegionEvent									///< 警戒区入侵事件
		{
			VideoAnalyseDetectAction		action;				///< 检测动作
			VideoAnalyseCrossRegionDirection direction : 8;		///< 检测方向
		} crossRegion;

		struct PreservationEvent								///< 物品保全
		{
			uint							duration; 			///< 持续时间，单位：秒
		} preservation;
		struct PreservationEvent left;							///< 遗留物品规则
		struct PreservationEvent takeAway;						///< 物品搬移规则
		struct PreservationEvent parking;						///< 非法停车规则

		struct ObjectDetectionEvent								///< 物品检测事件
		{
			uint						duration;				///< 持续时间，单位：秒
			VideoAnalyseDetectAction	action;					///< 检测动作
		}objectDetection;
		
		struct WanderEvent										///< 徘徊
		{
			ushort							targets;			///< 触发的报警人数
		} wander;
		struct WanderEvent stay;								///< 滞留
		
		struct RunEvent											///< 异常奔跑事件
		{
			VideoAnalyseRunDetectType		type;				///< 奔跑类型掩码
			uchar							speed;				///< 奔跑速度；单位：km/h
		} run;

		struct DensityEvent										///< 密集检测
		{
			VideoAnalyseDensityState	state;					///< 密集状态
		}density;

        struct FlowEvent                                ///< 流量统计，针对人、车等物体
        {
			unsigned int flow;						///< 统计个数
            int flowForward;                       ///< 正向流量统计
            int flowBackward;                      ///< 反向流量统计
            int personForward;                     ///< 人流量正向统计
            int personBackward;                    ///< 人流量反向统计
            int vehicleForward;                    ///< 车流量正向统计
            int vehicleBackward;                   ///< 车流量反向统计
            int unknowForward;                     ///< 未知目标正向统计
            int unknowBackward;                    ///< 未知目标反向统计
        }normalFlowStat;

		struct FlowEvent headCountStat;				///< 人头统计

		struct VideoAbnormalDetectionEvent						///< 视频异常检测
		{
			ulong							type;				///< 视频异常类型, 取值见 VideoAnalyseVideoAbnormalDetectionMask
		} videoAbnormalDetection;

		struct VideoFaceDetectionEvent
		{
			ushort							faceRegionNumber;	///< 检测到的人脸区域个数
			VideoAnalyseFaceInfo			*faceInfo;			///< 人脸信息
		} videoFaceDetectionEvent;

		struct VideoFaceDetectionEvent videoAbnormalFaceDetectionEvent;	///< 异常人脸检测事件

		struct VideoPlateDetectionEvent
		{
			Rect		PlateRegion;			///< 车牌区域信息
			char		license[16];			///< 车牌号码
			char		color[8];				///< 车牌颜色
			VideoAnalysePlateColor	nColor;		///< 车牌颜色枚举
			VideoAnalysPlateCategory nType;		///< 车牌类型
			int			nConfidence;			///< 整牌可信度
			int			nBright;				///< 亮度评价
			int			nDirection;				///< 车牌运动方向，0 unknown, 1 left, 2 right, 3 up , 4 down  BzPidRect 
		}videoPlateDetectionEvent;

		struct VideoPackingSpaceDetectionEvent
		{
			VideoAnalysePackingDetectAction action;		///< 普通车位检测动作
		}videoPackingSpaceDetectionEvent;
		
		/////////////////// 交通事件 //////////////////////////////////////////
		/// 以下事件使用通用事件结构：卡口,压白线,压黄线,压停止线,逆行, 违章变道,不按车道行驶, 
		/// 禁左,禁右,违章掉头,有车占道,黄牌占道, 行人礼让。其他事件使用各自对应的结构。
		///////////////////////////////////////////////////////////////////////
		struct TrafficGeneralEvent
		{
			char		laneNumber;				///< 车道编号
		} trafficGeneral;

		struct TrafficGateEvent					///<卡口
		{
			Rect		PlateRegion;				///< 车牌区域信息
			char		license[16];				///< 车牌号码
			VideoAnalysePlateColor	nColor : 8;		///< 车牌颜色枚举
			VideoAnalysPlateCategory nType : 8;		///< 车牌类型
			VideoAnalyseCarColor bodyColor : 8;		///< 车身颜色
			VideoAnalyseCarColor secondColor : 8;	///< 第二车身颜色
			float		firstRate;					///< 第一颜色比例
			float		secondRate;					///< 第二颜色比例 
			short		nDirection;					///< 车牌运动方向，0 unknown, 1 left, 2 right, 3 up , 4 down  BzPidRect 
			short		shutter;					///< 快门 
			short		gain;						///< 增益 
			short		fillLightState;				///< 闪光灯状态 
			short		speed;						///< 车速,单位: km/h
			char		triggerType;				///< 触发类型,0：模拟触发 1：视频触发 2：串口触发 3：IO触发 4: 其他触发5: 抓拍照片
			char		triggerLane;				///< 触发的车道，从0开始 
			unsigned int triggerId;					///< 触发的ID
		}trafficGate;
		
		struct TrafficRunRedLight
		{
			char		laneNumber;				///< 车道编号
			int			lightState;				///< 取VideoAnalyseTrafficLightCategory位与值
		} trafficRunReadLight;
		struct TrafficRunYellowLight
		{
			char		laneNumber;				///< 车道编号
			int			lightState;				///< 取VideoAnalyseTrafficLightCategory位与值
		} trafficRunYellowLight;
		struct TrafficStay
		{
			char		laneNumber;				///< 车道编号
			int			lightState;				///< 取VideoAnalyseTrafficLightCategory位与值
		} trafficStay;
		
		struct TrafficParkingEvent
		{
			int			laneNumber;				///< 车道编号
			uint		lastTime;				///< 报警时长，秒为单位
		} trafficParking;

		struct TrafficParkingOnYellowBoxEvent
		{	
			char		laneNumber;				///< 车道编号
			ushort 		interval1;				///<第一张和第二张之间的延时时间，单位秒
			ushort 		interval2;				///<第三张和第二张之间的延时时间，单位秒
			ushort 		followTime;				///<跟随时间，单位秒
		} TrafficParkingOnYellowBox;	
		
		struct TrafficJamEvent
		{
			int			laneNumber;				///< 车道编号
			uint		lastTime;				///< 报警时长，秒为单位
		} trafficJam;

		struct TrafficLightAbnormalEvent		///<交通灯异常
		{
			uchar lightGroup;					///<灯组号.
			VideoAnalyseTrafficLightAbnormalType  abnormalType;	///< 异常类型 
		} trafficLightAbnormal;

		struct TrafficFlowStatEvent				///< 交通流量统计
		{
			char	laneNumber;					///< 车道编号
			char	state;						///< 交通状态,1 流量过大, 2 流量恢复, 3 正常, 4 流量过小, 5 流量过小恢复
			ushort	flow;						///< 流量, 单位:辆
			ushort	peroid;						///< 流量值的统计时间，单位:分
		} trafficFlowStat;

		struct videoHumanShapeDetectionEvent
		{
			ushort  humanNumber;	///< 检测到的人形个数
		} videoHumanShapeDetectionEvent;

		struct FaceComparison
		{
			int num;							///< 比对成功个数
			VideoAnalyseCompInfo info[16];		///< 比对信息
		} faceComparison;		

		int placeholder[24];					///< 占位符，保证这个联合体体为96字节
	}result;
} VideoAnalyseEvent;

/// @} end of group

#ifdef __cplusplus
}
#endif

#endif //__VIDEO_ANALYSE_RULE_API_H__

